#include <iostream>
#include <memory>  // 需包含 <memory> 以使用 std::allocator
using namespace std;

template<typename T>
class Vector {
public:
    using iterator = T *;
    iterator begin(){
        return _start;
    }

    iterator end(){
        return _finish;
    }

    // 构造函数与析构函数
    Vector();                      // 默认构造函数：创建空 Vector
    ~Vector();                     // 析构函数：释放内存并销毁元素

    // 元素操作
    void push_back(const T& val);  // 在尾部添加元素（可能触发扩容）
    void pop_back();               // 删除尾部元素（不释放内存）

    // 容量与大小查询
    int size() const;              // 返回当前元素个数（_finish - _start）
    int capacity() const;          // 返回当前容量（_end_of_storage - _start）

private:
    // 内存管理函数
    void reallocate();             // 动态扩容：分配更大内存，拷贝元素，释放旧内存

    // 数据成员（空间与对象管理分离）
    static std::allocator<T> _alloc;  // 内存分配器：负责空间申请与对象构造/析构
    T* _start;                       // 指向数组中第一个元素的指针
    T* _finish;                      // 指向最后一个实际元素的下一个位置的指针
    T* _end_of_storage;              // 指向数组内存块末尾（容量边界）的指针
};

template<typename T>
allocator<T> Vector<T>::_alloc;

template<typename T>
Vector<T>::Vector()
: _start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{

}  

template<typename T>
Vector<T>::~Vector()                     // 析构函数：释放内存并销毁元素
{
    if (_start){
        while(_start != _finish){
            _alloc.destroy(--_finish);
        }
        _alloc.deallocate(_start, capacity());
    }
}

// 元素操作
template<typename T>
void Vector<T>::push_back(const T& val)  // 在尾部添加元素（可能触发扩容）
{
    if (size() == capacity()){
        reallocate();
    }
    if (size() < capacity()){
        _alloc.construct(_finish++, val);
    }
}

template<typename T>
void Vector<T>::pop_back()               // 删除尾部元素（不释放内存）
{
    if (size() > 0){
        _alloc.destroy(--_finish);
    }
}

// 容量与大小查询
template<typename T>
int Vector<T>::size() const              // 返回当前元素个数（_finish - _start）
{
    return _finish - _start;
}

template<typename T>
int Vector<T>::capacity() const          // 返回当前容量（_end_of_storage - _start）
{
    return _end_of_storage - _start;
}

// 内存管理函数
template<typename T>
void Vector<T>::reallocate()             // 动态扩容：分配更大内存，拷贝元素，释放旧内存
{
    //1、申请两倍的新空间
    int oldCapacity = capacity();
    int newCapacity = oldCapacity > 0 ? 2 * oldCapacity : 1;
    T *tmp = _alloc.allocate(newCapacity);

    if (_start){
        // 2、将老空间对象拷贝到新空间
        uninitialized_copy(_start, _finish, tmp);
    
        // 3、将老空间对象销毁并将老空间回收
        while(_start != _finish){
            _alloc.destroy(--_finish);
        }
        _alloc.deallocate(_start, oldCapacity);
    }

    // 4、三个指针重新与新空间产生关系
    _start = tmp;
    _finish = tmp + oldCapacity;
    _end_of_storage = tmp + newCapacity;
}

void printCapacity(const Vector<int> &vec){
    cout << "size() = " << vec.size() << endl;
    cout << "capacity() = " << vec.capacity() << endl;
}

void test(){
    Vector<int> vec;
    vec.push_back(1);
    printCapacity(vec);

    vec.push_back(2);
    printCapacity(vec);

    vec.push_back(3);
    printCapacity(vec);

    vec.push_back(4);
    printCapacity(vec);

    vec.push_back(5);
    printCapacity(vec);

    for (auto &elem : vec){
        cout << elem << " ";
    }
    cout << endl;
}

int main(){
    test();

    return 0;
}